import requestAPI from '../../utils/requestApi'; // 确保路径正确引入请求实例
const areaValueToDistrictMap = {
  1: '荷花村'.toUpperCase(),
  2: '三山村'.toUpperCase(),
  3: '湖田村'.toUpperCase(),
  // 可以在这里继续添加其他地区的映射关系
};

Page({
  data: {
    // 地区下拉框相关数据
    areaValue: 0,
    areaOptions: [{
        text: '荷花村',
        value: 1
      },
      {
        text: '三山村',
        value: 2
      },
      {
        text: '湖田村',
        value: 3
      },
      // 可以根据实际需求添加更多地区选项
    ],
    levelValue: 0, // 初始化为不限，用数字1表示（这里与你之前的注释可能有出入，按照后续逻辑应该是1表示不限，2表示热门活动更合理）
    levelOptions: [{
        text: '不限',
        value: 1
      },
      {
        text: '热门活动',
        value: 2
      }
    ],
    isLevelDropdownShow: false,
    searchValue: '',
    categoryList: [],
    secondaryCategoryData: [],
    searchResults: [],
    activeIndex: 0,
    // 添加数据获取状态标识
    isDataFetching: false,
    scrollTop: 0 // 用于记录滚动的距离
  },

  // 在页面加载时请求后端数据
  onLoad: function () {
    this.fetchDataFromBackend();
  },

  onInputChange: function (e) {
    this.setData({
      searchValue: e.detail.value
    });
  },

  // 从后端获取数据的通用函数
  fetchDataFromBackend(params) {
    const that = this;
    const relativeUrl = '/258363342';
    // 使用封装好的GET请求方法
    return requestAPI.get(relativeUrl, params).then((res) => {
        if (res.code === 200) {
          const categoryList = this.processBackendData(res.data.categoryList);
          // 调整一级分类的id，使其从0开始，以适应前端索引体系
          categoryList.forEach((category, index) => {
            category.id = index;
          });
          this.setData({
            categoryList: categoryList
          });
          this.updateSecondaryCategoryData();

          // 数据获取成功，设置数据获取状态为 false
          this.setData({
            isDataFetching: false
          });
        } else {
          console.error('获取数据失败，错误信息：', res.message);

          // 数据获取失败，设置数据获取状态为 false
          this.setData({
            isDataFetching: false
          });
        }
      })
      .catch((err) => {
        console.error('网络请求失败，错误信息：', err);

        // 数据获取失败，设置数据获取状态为 false
        this.setData({
          isDataFetching: false
        });
      });
  },

  // 处理后端返回数据的函数，可根据实际情况进行更多数据处理
  processBackendData: function (categoryList) {
    categoryList.forEach((category) => {
      category.children.forEach((child) => {
        if (child.imageUrl === null) {
          // 设置默认图片路径，可根据实际需求修改
          child.imageUrl = 'https://example.com/default_image.jpg';
        }
      });
    });

    return categoryList;
  },

  // 统一构建请求参数的函数
  buildRequestParams(areaValue, levelValue) {
    let districtValue;
    // 根据映射对象获取后端期望的district值，如果不存在则使用原areaValue并转换为大写
    districtValue = areaValueToDistrictMap[areaValue] || areaValue.toUpperCase();

    let hotParam;
    if (levelValue === 2) {
      hotParam = true;
    } else {
      hotParam = false;
    }

    return {
      district: districtValue,
      hot: hotParam
    };
  },

  // 地区下拉框
  onAreaChange(event) {
    this.setData({
      areaValue: event.detail
    });
    console.log('地区选择变化，当前选择：', this.data.areaValue);

    // 设置数据获取状态为正在进行
    this.setData({
      isDataFetching: true
    });

    // 先清空之前可能存在的缓存数据
    this.setData({
      categoryList: []
    });

    const levelValue = this.data.levelValue;
    const params = this.buildRequestParams(event.detail, levelValue);

    this.fetchDataFromBackend(params);
  },

  // 地区
  fetchDataByAreaFromBackend: function (areaValue) {
    let districtValue;
    // 根据映射对象获取后端期望的district值，如果不存在则使用原areaValue并转换为大写
    districtValue = areaValueToDistrictMap[areaValue] || areaValue.toUpperCase();
    const params = {
      district: districtValue
    };
    return requestAPI.get('/travel/actives/lists', params)
      .then((res) => {
        if (res.code === 200) {
          const categoryList = this.processBackendData(res.data.categoryList);
          // 调整一级分类的id，使其从0开始，以适应前端索引体系
          categoryList.forEach((category, index) => {
            category.id = index;
          });

          this.setData({
            categoryList: categoryList
          });

          this.updateSecondaryCategoryData();
        } else {
          console.error('获取数据失败，错误信息：', res.message);
        }
      })
      .catch((err) => {
        console.error('网络请求失败，错误信息：', err);
      });
  },

  onLevelChange(event) {
    this.setData({
      levelValue: event.detail
    });
    console.log('活动热度选择变化，当前选择：', this.data.levelValue);

    // 设置数据获取状态为正在进行
    this.setData({
      isDataFetching: true
    });

    // 先清空之前可能存在的缓存数据
    this.setData({
      categoryList: []
    });

    const areaValue = this.data.areaValue;
    const params = this.buildRequestParams(areaValue, event.detail);

    this.fetchDataFromBackend(params);
  },

  // 活动热度
  fetchDataByLevelFromBackend: function (levelValue) {
    let hotParam;
    if (levelValue === 2) {
      hotParam = true;
    } else {
      hotParam = false;
    }
    const params = {
      hot: hotParam
    };
    return requestAPI.get('/travel/actives/lists', params).then((res) => {
        if (res.code === 200) {
          const categoryList = this.processBackendData(res.data.categoryList);

          // 调整一级分类的id，使其从0开始，以适应前端索引体系
          categoryList.forEach((category, index) => {
            category.id = index;
          });

          this.setData({
            categoryList: categoryList
          });
          this.updateSecondaryCategoryData();
        } else {
          console.error('获取数据失败，错误信息：', res.message);
        }
      })
      .catch((err) => {
        console.error('网络请求失败，错误信息：', err);
        // 数据获取完成，设置数据获取状态为 false
        this.setData({
          isDataFetching: false
        });
      });
  },

  onInput(event) {
    console.log('获取到输入框的值：', event.detail.value);
    this.setData({
      searchValue: event.detail.value
    });
    console.log('在设置后的searchValue：', this.data.searchValue);
  },

  toSearch() {
    const searchValue = this.data.searchValue;

    // 验证搜索值是否为空
    if (!searchValue) {
      wx.showToast({
        title: '请输入搜索内容',
        icon: 'none',
        duration: 2000
      });
      return;
    }

    this.fetchDataBySearchValueFromBackend(searchValue)
      .then((res) => {
        // 隐藏加载提示框，无论搜索结果如何，加载过程结束都要隐藏
        wx.hideLoading();

        if (res.code === 200) {
          const categoryList = res.data.categoryList;
          if (categoryList.length === 0) {
            wx.showToast({
              title: '未找到相关搜索结果',
              icon: 'none',
              duration: 2000
            });
          } else {
            wx.showToast({
              title: '搜索成功，已找到相关结果',
              icon: 'success',
              duration: 2000
            });
          }
        } else {
          wx.showToast({
            title: '搜索失败，请稍后再试',
            icon: 'none',
            duration: 2000
          });
        }
      })
      .catch((err) => {
        console.error('网络请求失败，错误信息：', err);
      });
  },

  // 根据搜索关键词从后端获取数据的函数
  fetchDataBySearchValueFromBackend: function (searchValue) {
    return requestAPI.get('/travel/actives/lists', {
        name: searchValue
      })
      .then((res) => {
        if (res.code === 200) {
          const categoryList = this.processBackendData(res.data.categoryList);
          // 调整一级分类的id，使其从0开始，以适应前端索引体系
          categoryList.forEach((category, index) => {
            category.id = index;
          });

          this.setData({
            categoryList: categoryList
          }, () => {
            // 处理搜索结果为空的情况
            if (categoryList.length === 0) {
              console.log('搜索无结果');
              // 弹出提示框显示查询不到
              wx.showToast({
                title: '查询不到相关数据',
                icon: 'none',
                duration: 2000
              });

              // 刷新回到最原始的状态
              this.resetToOriginalState();
              return;
            }

            // 遍历搜索结果，找到匹配title所在的一级分类位置并更新activeIndex
            const categoryIndex = this.extractCategoryIndexByTitle(searchValue);
            if (categoryIndex !== -1) {
              this.setData({
                activeIndex: categoryIndex
              });
              this.updateSecondaryCategoryData();
            }
          });

        } else {
          console.error('获取数据失败，错误信息：', res.message);
        }
      })
      .catch((err) => {
        console.error('网络请求失败，错误信息：', err);
      });
  },

  // 获取所有活动数据的辅助函数
  getAllActivityData() {
    let allData = [];
    this.data.categoryList.forEach(category => {
      allData = allData.concat(category.children);
    });
    return allData;
  },

  // 实现一级分类的切换效果
  updateActive(event) {
    const targetId = event.currentTarget.dataset.id; // 假设点击元素的数据集里有id属性，需确保在模板中设置了这个属性

    const categoryList = this.data.categoryList;
    const targetIndex = categoryList.findIndex(category => category.id === targetId);

    if (targetIndex !== -1) {
      this.setData({
        activeIndex: targetIndex
      });

      // 获取当前激活的一级分类下的二级分类数据
      const currentCategory = categoryList.find(category => category.id === targetId);
      const secondaryCategoryList = currentCategory.children;

      // 根据活动热度选择来处理二级分类数据的展示
      this.updateSecondaryCategoryData(secondaryCategoryList);
    }
  },

  updateSecondaryCategoryData(secondaryCategoryList = this.data.categoryList[this.data.activeIndex].children) {
    const levelValue = this.data.levelValue;

    console.log("更新前的二级分类数据:", this.data.secondaryCategoryData);
    // 先获取二级分类数据长度，用于后续判断是否为空
    const secondaryListLength = secondaryCategoryList.length;
    if (levelValue === 2) {
      // 如果选择热门活动，根据hot属性对二级分类数据进行排序，让热度值高的活动排在前面
      const sortedData = secondaryCategoryList.sort((a, b) => b.hot - a.hot);
      this.setData({
        secondaryCategoryData: sortedData
      });
    } else {
      // 如果选择的是不限（包括默认情况，即未选择活动热度时），按照children的id进行排序展现
      const sortedData = secondaryCategoryList.sort((a, b) => a.id - b.id);
      this.setData({
        secondaryCategoryData: sortedData
      });
    }

    // 判断更新后二级分类数据是否为空，如果为空则弹出提示框
    if (!secondaryListLength) {
      wx.showToast({
        title: '查询不到',
        icon: 'none',
        duration: 2000 // 这里将提示框显示时间设置为3秒，你可以根据需要调整
      });
      // 使用setTimeout设置延迟3秒（与提示框显示时间相同）后执行跳转和清空操作
      setTimeout(() => {
        // 清空搜索框的内容
        this.setData({
          searchValue: ''
        });

        // 调用函数重置页面到初始状态（未点击搜索等操作时的状态）
        this.resetToOriginalState();
      }, 3000);
    }
  },

  // 根据地区值获取地区文本的辅助函数
  getAreaTextByValue(value) {
    const areaOption = this.data.areaOptions.find(option => option.value == value);
    let areaText = areaOption ? areaOption.text : '';

    // 假设后端要求地区文本去除首尾空格并且全大写，可根据实际情况调整
    areaText = areaText.trim().toUpperCase();
    return areaText;
  },

  // 根据活动标题查找所在一级分类索引的辅助函数
  extractCategoryIndexByTitle(title) {
    const categoryList = this.data.categoryList;
    let matchCounts = [];

    categoryList.forEach((category, index) => {
      let count = 0;
      category.children.forEach((child) => {
        if (child.title.includes(title)) {
          count++;
        }
      });
      matchCounts[index] = count;
    });

    return matchCounts.indexOf(Math.max(...matchCounts));
  },

  // 新增函数，用于刷新回到最原始的状态
  resetToOriginalState() {
    this.setData({
      searchValue: '',
      secondaryCategoryData: [],
      activeIndex: 0
    });
    this.fetchDataFromBackend();
  },

  // 活动点击事件处理函数
  onActivityClick(event) {
    console.log('点击活动事件对象:', event);
  }
})